package linkedList;

import java.util.Iterator;
import java.util.function.Consumer;

/**
 * 单向链表
 *
 * @author yyz
 * @create 2023-11-10 18:27
 */
public class SingleLinkedList implements Iterable<Integer> {
    private ListNode head;

    /**
     * 在链表头后添加值
     *
     * @param value 待添加的值
     */
    public void addFirst(int value) {
        head = new ListNode(value, head);
    }

    /**
     * 在链表的尾部添加值
     *
     * @param value 待添加的值
     */
    public void addLast(int value) {
        ListNode last = findLast();
        //链表为空
        if (last == null) {
            addFirst(value);
            return;
        }

        last.next = new ListNode(value, null);
    }

    /**
     * 获取指定索引的节点值
     *
     * @param index 索引
     * @return 节点值
     */
    public int get(int index) {
        ListNode p = findNode(index);
        if (p != null) return p.val;

        throw IllegalArgumentException(index);
    }

    /**
     * 删除第一个位置的节点
     */
    public void removeFirst() {
        if (head == null) {
            return;
        }
        head = head.next;
    }

    /**
     * 根据索引删除节点
     *
     * @param index 索引
     */
    public void remove(int index) {
        if (index == 0) {
            removeFirst();
            return;
        }

        ListNode pre = findNode(index - 1);
        if (pre == null) {
            throw IllegalArgumentException(index);
        }
        ListNode remove = pre.next;
        if (remove == null) {
            throw IllegalArgumentException(index);
        }
        pre.next = remove.next;
    }

    /**
     * 插入值到指定索引的节点
     *
     * @param index 索引
     * @param value 值
     */
    public void insert(int index, int value) {
        if (index == 0) {
            addFirst(value);
            return;
        }

        ListNode pre = findNode(index - 1);
        if (pre == null) {
            throw IllegalArgumentException(index);
        }
        pre.next = new ListNode(value, pre.next);
    }

    /**
     * 索引异常
     *
     * @param index 索引位置
     * @return 异常
     */
    private static IllegalArgumentException IllegalArgumentException(int index) {
        return new IllegalArgumentException(String.format("index[%d] 不合法", index));
    }

    /**
     * 根据索引查找节点
     *
     * @param index 索引
     * @return 节点
     */
    private ListNode findNode(int index) {
        int i = 0;
        ListNode p;
        for (p = head; p != null; p = p.next, i++) {
            if (index == i) {
                return p;
            }
        }
        return null;
    }

    /**
     * 找到链表的尾部
     *
     * @return 链表最后一个节点，如果头节点为空则返回null
     */
    private ListNode findLast() {
        if (head == null) {
            return null;
        }
        ListNode p;
        for (p = head; p.next != null; ) {
            p = p.next;
        }
        return p;
    }

    /**
     * 函数遍历
     *
     * @param consumer 遍历要执行的操作
     */
    public void loop(Consumer<Integer> consumer) {
        ListNode p = head;
        while (p != null) {
            consumer.accept(p.val);
            p = p.next;
        }
    }

    /**
     * 迭代器遍历
     */
    @Override
    public Iterator<Integer> iterator() {

        return new Iterator<Integer>() {
            ListNode p = head;

            @Override
            public boolean hasNext() {
                return p != null;
            }

            @Override
            public Integer next() {
                int val = p.val;
                p = p.next;
                return val;
            }
        };
    }

}
